home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 October / EnigmA AMIGA RUN 01 (1995)(G.R. Edizioni)(IT)[!][issue 1995-10][Aminet 7].iso / Aminet / misc / emu / bbtools1_1.lha / BBTools.doc next >
Text File  |  1995-06-06  |  17KB  |  371 lines

  1.  
  2.                           BridgeBoard Tools
  3.  
  4.                              Version 1.10
  5.  
  6.                   Copyright (c) 1994 M. C. Henderson
  7.  
  8.  
  9.          These programs have been tested extensively. However,
  10.         use them is at your own risk. I will not be responsible
  11.         for any damage or loss of data caused directly or indirectly
  12.         by these programs. In other words, make sure you have backups
  13.         of your valuable data!
  14.  
  15.     History
  16.  
  17.     1.0  Initial release
  18.  
  19.     1.1  Programs changed to prevent lockup when reading non-JDisk files.
  20.          ReadJD fixed to prevent lockup when wildcarding a whole
  21.          directory. Number of files ReadJD and WriteJD will handle
  22.          increased from 300 to 1000. An option added to MakeJD to
  23.          force a JLink. An option added to WriteJD to force an update
  24.          of the PC's directories. A PC program "DIRUD.EXE" was added to
  25.          implement this change to WriteJD. Also, the name of this package
  26.          of programs was changed from "BPTools" to "BBTools". For some
  27.          dumb reason I started calling it a BridgePort instead of a
  28.          BridgeBoard.
  29.  
  30.  
  31. 1.0 Introduction
  32.  
  33.   The BridgeBoard comes with a set of utility programs which allow you to
  34.   create and use virtual IBM disk drives on the Amiga. These JDisk drives
  35.   can be written to and read from using the IBM programs AWRITE.EXE and
  36.   AREAD.EXE. Although these programs can be fine for transferring small
  37.   amounts of data, they can be slow when large files are being moved. I wrote
  38.   these Amiga programs included herein so I could quickly transfer large
  39.   amounts of data to the JDisks located on the Amiga.
  40.     
  41.     Using an Amiga 3000 with a 286 BridgeBoard, the WriteJD program will
  42.   write a 250KB file from the harddrive to a ram based JDisk file in
  43.   approximately 9 seconds versus 62 seconds using the AREAD program. The
  44.   ReadJD program will transfer this same file from the JDisk to Amiga ram in
  45.   approximately 6 seconds versus 62 seconds using AWRITE.  
  46.  
  47.  
  48. 2.0 Programs
  49.   
  50.   BBTools consists of five programs:
  51.  
  52.   1. "JDir" is an Amiga program which allows you to get a directory listing 
  53.       of  a JDisk file while in the Amiga mode.
  54.  
  55.   2. "MakeJD" is an Amiga program which allows you to create a JDisk drive
  56.       while in the the Amiga mode.
  57.  
  58.   3. "ReadJD" is an Amiga program which allows you to read files from a JDisk
  59.       file while in the Amiga mode.
  60.  
  61.   4. "WriteJD" is an Amiga program which allows you to write to a JDisk file
  62.       while in the Amiga mode.
  63.  
  64.   5. "DIRUD.EXE" is an IBM program which will force an update of directories
  65.       on all the IBM drives. This program goes in either your Janus or
  66.       DOS directory on the IBM.
  67.  
  68. 3.0 Instructions
  69.  
  70.       In the instructions given below I have assumed that the reader has
  71.     a good working knowledge of creating and working with JDisk files.
  72.     If not, I suggest you throughly read the your BridgeBoard user's
  73.     guide. Particularly the information on using JLINK.EXE, AREAD.EXE
  74.     and AWRITE.EXE.
  75.       Note that these programs only work with jlinked JDisk files (virtual
  76.     IBM disks). They will not read or write to psuedo IBM harddrives.  
  77.       
  78.   3.1  JDir
  79.  
  80.       As stated above, JDir is an Amiga program for getting a directory  
  81.     listing of a JDisk file from the Amiga side. This JDisk file could have
  82.     been created on the IBM side with the JLINK.EXE program or the MakeJD   
  83.     program discused below. Use the following syntax to get a directory  
  84.     listing:
  85.   
  86.                   JDir vd
  87.  
  88.       Where vd is the full path name of the JDisk file on the Amiga (eg
  89.     DH1:IBMdata/vd). Note that there is no colon after the file name. If it 
  90.     is included, the Amiga will think you are asking for a volume name and 
  91.     put up a requester asking for it.
  92.  
  93.       The syntax for subdirectors is:
  94.       
  95.                   JDir vd\dir1\dir2\dir3
  96.                   
  97.       Note that the IBM backslash convention was used to separate directory
  98.     entries. This was done so the Amiga would not treat these entries as a
  99.     request for information on an Amiga file.
  100.     
  101.       The IBM wildcard symbol "*" (asterick) can be used to get information
  102.     on specific files:
  103.     
  104.                   JDir ram:vd\dir1\*.exe
  105.                   
  106.       This command will list all the files in subdirectory "dir1" that end in
  107.     "exe".
  108.                   
  109.     Limitations:
  110.     
  111.      JDir doesn't have any fancy options such as /p or /w to
  112.     get paged listings. Maybe this is something which could be added if
  113.     there is a request for it.                
  114.                         
  115.  
  116.   3.2 MakeJD
  117.   
  118.      MakeJD is an Amiga program to create a JDisk file on the Amiga. The
  119.    program is similar to the BridgeBoard IBM program called JLINK.EXE. It
  120.    will create a file on the Amiga which acts as a virtual disk drive on
  121.    the IBM. MakeJD will allow you to create a JDisk file and the programs
  122.    WriteJD and ReadJD discussed below will allow you to write and read
  123.    files to it. MakeJD will NOT however, jlink the file to the IBM. You
  124.    must still do this using JLINK.EXE. As discussed below, an option has
  125.    been added to MakeJD to force the IBM to run JLINK.
  126.    
  127.      The syntax for using MakeJD is:
  128.      
  129.                   MakeJD JDisk kilobytes
  130.                   
  131.       Where "JDisk" is the full path and file name of the file you wish to
  132.     create (eg. Ram:dir/vd). "kilobytes" is the number of kilobytes you
  133.     want to assign to this virtual drive (eg. 300 = 300,000 bytes). Note that
  134.     like JLINK.EXE, MakeJD does not create a file that is "kilobytes" large,
  135.     it only creates a file which is allowed to become this size. The file
  136.     becomes larger as you add files to it. Like JLINK.EXE, MakeJD will
  137.     create JDisk files from 160KB to 30MB.
  138.  
  139.       In the 1.10 update, an option was added to force a jlink of the JDisk to
  140.     to an IBM drive. If a pcwindow is open, the program will ask if you want
  141.     to link the newly created JDisk to the PC. If you anwser yes (y), the
  142.     program will ask for a drive letter (eg. d). When the program receives
  143.     a drive letter, it will send a message to the PC to jlink the JDisk to
  144.     this drive. The program uses the JLINK.EXE program on the PC, so the
  145.     JLINK.EXE program must be in your Janus directory on the PC. If a
  146.     pcwindow is not currently open, you won't receive this query.
  147.  
  148.       Note that this option will not work if you are using the program
  149.     SXSERV as your link to the PC. This program does not use a pcwindow so
  150.     there is not anything for my program to detect and you won't be asked if
  151.     you want to link it. I'am looking into a way around this. You can still
  152.     use MakeJD to create the JDisk if you use SXSERV, but you will have to
  153.     link it manually using JLINK on the PC.
  154.     
  155.       As a sample session, assume you want to create a 300KB JDisk file
  156.     named "vd" in ram and make this file drive d: on the IBM. You would enter:
  157.     
  158.                  MakeJD ram:vd 300
  159.                  
  160.       If a pcwindow is open, the program will ask if you want to link it.
  161.       Enter "y". The program will ask for a drive letter. Enter the drive
  162.       letter.
  163.  
  164.       If a pcwindow is not open, you won't receive these queries, so go to
  165.       the PC and enter:
  166.  
  167.                  jlink d: ram:vd
  168.     
  169.       When you were through with it, you could unlink it by entering:
  170.       
  171.                  jlink d: /u
  172.                  
  173.       Of course it would have been just as easy to create the JDisk on the
  174.     IBM without using MakeJD if this all you wanted to do. The primary
  175.     reason for writing MakeJD was so I could create the JDisk on the Amiga,
  176.     transfer files to it on the Amiga side, then go to the IBM side and
  177.     link it. In my case, I have a VGA card and I have to change the
  178.     monitor output before going to the BridgeBoard, hence it is
  179.     nicer (and faster) to be able transfer the data before I switch over.
  180.     
  181.                        
  182.     Limitations:
  183.     
  184.       MakeJD has none of the options of JLINK.EXE. It doesn't have a /N
  185.     option because there are not really any messages to surpress. It doesn't
  186.     have a /U option because as explained above, JLINK.EXE must be used
  187.     to link and unlink the JDisk to the IBM. I have never used the /R
  188.     option (create a read only file) with JLINK.EXE, so I didn't include
  189.     it in MakeJD. Again, if this is an option you would like included,
  190.     let me know and I'll look into it.  
  191.     
  192.       Although not a limitation, the file sizes created by MakeJD may not
  193.     always correspond to the file sizes that would be created by JLINK.EXE.
  194.     I spent considerable time trying to figure out the criteria used in
  195.     the JLINK program for assigning file sizes, but never made much sense
  196.     of it. I finally gave up and used my own criteria. As an example,if you
  197.     ask  for a 165KB file with JLINK, you get a 163KB file. With MakeJD you
  198.     will  always get a file at least as large as you have requested. Note
  199.     that neither JLINK or MakeJD can give you exactly the file size you
  200.     request because the sizes depend on number of heads, sectors, etc.
  201.         
  202.                      
  203.    3.3 ReadJD
  204.     
  205.      ReadJD is an Amiga program which is anologous to the program called
  206.    AWRITE.EXE on the IBM side. AWRITE will write a JDisk file to the Amiga.
  207.    ReadJD will accomplish the same task by reading the JDisk on the Amiga
  208.    side, but much faster.   
  209.         
  210.      ReadJD will read files from any JDisk file using the following syntax:
  211.      
  212.                    ReadJD vd\dir1\dir2\jname ram:outname 
  213.                    
  214.      This would read a file named "jname" from subdirectory "dir1\dir2" of
  215.    JDisk "vd" and write a file "outname" in ram:. If the output name were
  216.    omitted, the file name "jname" would be written to the current directory.
  217.    Note that back slashes must be used to separate directory entries and
  218.    that no colon is used between the JDisk name and the directory entries.
  219.    If there were no directories, the syntax would be:
  220.    
  221.                    ReadJD vd\jname
  222.                    
  223.      This would read the file name "jname" and write it to the current
  224.    directory. Again, there is no colon between the JDisk and file name.
  225.    The Amiga interperts the colon as being part of a volume name, and
  226.    will put up a requester asking for it.
  227.    
  228.      The IBM style wildcard symbol "*" (asterick) can be used to read
  229.    multiple files, as for example:
  230.    
  231.                    ReadJD vd\*.c
  232.                    
  233.       This would read all files with a "c" extension into the current
  234.     Amiga directory. 
  235.                            
  236.       There is only one option with ReadJD, /t. I'am sure not everone will
  237.     be happy with it. I have flipped the /b option that is used with
  238.     the IBM program AWRITE.EXE. The /b option is used in AWRITE to specify
  239.     binary files. Since most of the files I transfer are binary and I was
  240.     always forgetting to add the /b. I wrote ReadJD to handle binary as
  241.     the default mode. To transfer text files, you must add a /t. This
  242.     option will strip the carriage returns from the IBM text files.     
  243.     For example:
  244.     
  245.                    ReadJD vd\ibm.txt dh1:amiga.txt /t
  246.                    
  247.       This would read the IBM text file "ibm.txt", strip the carriage
  248.     returns, and write a file named "amiga.txt" to drive dh1:. The
  249.     option /t must be the last entry of the command.
  250.     
  251.                          
  252.     Limitations:
  253.     
  254.       As mentioned above, I substituted /t for reading text files for the
  255.     /b option used in AWRITE.EXE for writing binary files. At present
  256.     there is no /cr or /nc options. Let me know if these are desired.  
  257.  
  258.     3.4 WriteJD
  259.     
  260.       WriteJD is anologous to the BridgeBoard program AREAD.EXE. The IBM
  261.     program AREAD is used to read Amiga files to a JDisk. WriteJD is an
  262.     Amiga program used to write Amiga files to a JDisk (but much faster).
  263.     The syntax is as follows:
  264.     
  265.                   WriteJD dh0:amiga.dat vd\dir1\dir2
  266.                   
  267.       This command would write the file named "amiga.dat" found on drive
  268.     dh0: to JDisk "vd" into subdirectory "dir1\dir2". Note that as with
  269.     ReadJD, back slashes are used to separate subdirectory entries on the
  270.     JDisk and no colon is used between the JDisk name subdirectories. If
  271.     there were no subdirectories on the JDisk, the commamd would have
  272.     simply been:
  273.     
  274.                  WriteJD dh0:amiga.dat vd
  275.                  
  276.       You can also write to a specific file name on the JDisk:
  277.       
  278.                  WriteJD ram:amiga.dat vd\ibm.dat
  279.                  
  280.       This would transfer the file named "amiga.dat" in ram to JDisk "vd"
  281.     and name it "ibm.dat".
  282.     
  283.       You can also use wildcards to transfer files:
  284.       
  285.                  WriteJD work:cprogs/*.c vd\cprogs
  286.                  
  287.       This command would transfer all files with a "c" extension found in
  288.     the Amiga volume "work",subdirectory "cprogs" to JDisk "vd" subdirectory
  289.     "cprogs".
  290.     
  291.      It should be noted that WriteJD will not create directories
  292.     on the JDisk if they don't exist. This example assumes that the
  293.     subdirectory "cprogs" had been created on the JDisk "vd" using the
  294.     MSDOS command mkdir.
  295.     
  296.       As with the ReadJD program, the default mode on WriteJD is binary.
  297.     All of the files in the examples above would have been written to the
  298.     JDisk as is. To write text files to a JDisk, a /t option would be
  299.     required:
  300.     
  301.                  WriteJD ram:amiga.txt vd\ibm.txt /t
  302.                  
  303.       The /t option would cause a carriage return to be inserted before
  304.     every line feed. The above command would read the file "amiga.txt" from
  305.     ram, insert carriage returns, and write it to the file "ibm.txt" on
  306.     the JDisk "vd". As with ReadJD, the /t option must be the last entry
  307.     in the command line.
  308.  
  309.       An option was added to the 1.10 version to update the directories on
  310.     the PC. If you use the Amiga to write to the JDisk, the PC will not
  311.     know about it. It uses an image of the directory stored in RAM. If
  312.     you enter a DIR command it will not show the files you just wrote. If
  313.     you use the IBM to write to this JDisk, it will corrupt it.
  314.  
  315.       Originally the only way to prevent corrupting the JDisk was to either
  316.     unlink the JDisk and relink it, or to do enter a CHKDSK command on the
  317.     PC. The problem was that it was easy to forget to do it. Also, unlinking
  318.     and linking was a hassle. Using CHKDSK could take a while and printed a
  319.     lot of stuff. In the current version of WriteJD, the program checks to
  320.     see if pcwindow is running, if it is, the program will ask if you want to
  321.     update the PC directories. If you answer yes (y), the program will
  322.     force the IBM to run the program "DIRUD.EXE" which will update all
  323.     directories on the IBM. The program "DIRUD.EXE" must be in your Janus
  324.     or DOS directory on the IBM for this option to work.
  325.  
  326.       If pcwindow is not running, you won't get this queary, but in this
  327.     case you aren't linked to the JDisk. When you start the PC and jlink
  328.     to JDisk, the directories will automatically be updated.
  329.  
  330.       Like MakeJD, this option will not work if you are using SXSERV. If
  331.     you are using this program you have three options, unlink and relink,
  332.     or enter a CHKDSK command on the PC, or you can run the DIRUD program
  333.     manually on the PC.
  334.     
  335.    Limitations:
  336.     
  337.       As mentioned above, I substituted /t for writing text files for the
  338.     /b option used in AREAD.EXE for reading binary files. At present
  339.     there is no /cr or /nc options. Let me know if these are desired.  
  340.        
  341.                          WARNING
  342.                          
  343.        As stated above, if you have a JDisk linked to the Amiga and do
  344.     subsequent writes with WriteJD, either have WriteJD send a command to
  345.     update the directories, or unlink and relink it, or do a CHKDSK, or
  346.     DIRUD command. If you use the BridgeBoard to write to this JDisk without
  347.     doing this it will corrupt the JDisk.
  348.       
  349.       There is also something that I discovered when I wrote these programs.
  350.     If you overwrite an existing file and you run out of disk space, you will
  351.     lose the original file on the disk. This is the case whether you are
  352.     using MSDOS, AREAD.EXE or my program WriteJD. All of these programs
  353.     destroy the orginal to make room for the new copy, so if it can't
  354.     find room for the new, the orginal is gone. Of course, you can always
  355.     write the file to another storage device. 
  356.                                 
  357.                     
  358.      Comments, errors, suggestions can be sent to:
  359.      
  360.      
  361.                       Milt Henderson
  362.                       6815 Wallsey Dr.
  363.                       San Diego,Ca USA
  364.                       92119
  365.                       mhenders@torment.cts.com
  366.                       
  367.       Like I stated above, I have spent considerable time trying to beat all
  368.     the errors out of these programs, but you never know. Be sure your data
  369.     is backed-up.
  370.       
  371.